
package com.jf.cloud.payment.feign;

import cn.hutool.core.collection.CollUtil;
import com.jf.cloud.api.payment.dto.OrderPayInfoDTO;
import com.jf.cloud.api.payment.feign.PaymentFeignClient;
import com.jf.cloud.common.constant.Constant;
import com.jf.cloud.common.response.ResponseEnum;
import com.jf.cloud.common.response.ServerResponseEntity;
import com.jf.cloud.payment.bo.PayInfoResultBO;
import com.jf.cloud.payment.manager.PayManager;
import com.jf.cloud.payment.manager.PayNoticeManager;
import com.jf.cloud.payment.mapper.PayInfoMapper;
import com.jf.cloud.payment.model.PayInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RestController;
import io.swagger.v3.oas.annotations.Hidden;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * @author zz
 * @Date 2022/08/10 9:21
 */
@RestController
@Hidden
public class PaymentFeignController implements PaymentFeignClient {

    private static final Logger log = LoggerFactory.getLogger(PaymentFeignController.class);

    @Autowired
    private PayManager payManager;
    @Autowired
    private PayNoticeManager payNoticeManager;
    @Autowired
    private PayInfoMapper payInfoMapper;

    /**
     * 情况一、 只支付了一次，且已支付： 调用订单支付成功处理，调用失败就打印日志，等待下一次调用
     * 情况二、 两条支付记录，一条已支付，一条未支付： 无论执行顺序怎样，未支付的记录不会处理，已支付的进行订单支付成功处理
     * 情况三、 三条支付记录，两条已支付，一次未支付： 未支付的记录不会处理，已支付的记录按创建时间进行订单支付成功处理，存在以下几种情况：
     *        1.第一条已支付记录处理后，订单状态变更为待发货，第二条已支付记录就会进行退款
     *        2.第一条已支付记录处理异常（服务出问题了，应该等待服务恢复后再处理），打印错误日志不再进行后续处理
     *
     * @param orderPayInfoDTO 订单id列表
     * @return
     */
    @Override
    public ServerResponseEntity<List<Long>> queryAndHandleOrderPaySuccess(OrderPayInfoDTO orderPayInfoDTO) {
        List<Long> orderIdList = new ArrayList<>();
        if (CollUtil.isEmpty(orderPayInfoDTO.getOrderIds())) {
            return ServerResponseEntity.success(orderIdList);
        }
        // 查询订单已经支付记录
        List<PayInfo> payInfoList = payInfoMapper.listPayedInfoByOrderIds(orderPayInfoDTO.getOrderIds(), orderPayInfoDTO.getUserId());

        if (CollUtil.isEmpty(payInfoList)) {
            return ServerResponseEntity.success(orderIdList);
        }

        for (PayInfo payInfo : payInfoList) {
            // 第三方平台查询已支付成功的订单
            PayInfoResultBO payInfoResultBO = payManager.checkPaySuccess(payInfo);

            // 没有支付
            if (Objects.equals(payInfoResultBO.getPaySuccess(), Boolean.FALSE)) {
                continue;
            }
            // 已支付成功或查询支付接口异常，订单id先添加到支付成功的id列表中，优先保证订单不会被取消
            String[] orderIdArray = payInfo.getOrderIds().split(Constant.COMMA);
            for (String s : orderIdArray) {
                orderIdList.add(Long.valueOf(s));
            }
            //  查询支付接口异常就不能进行后续处理了
            if (Objects.isNull(payInfoResultBO.getPaySuccess())) {
                continue;
            }
            // 处理已支付成功，但订单状态还是待支付的订单
            payInfoResultBO.setCallbackContent("取消订单时-支付成功");

            // 服务出问题了等待服务恢复后再处理，先打印错误日志不再进行后续处理，等待下一场处理
            ResponseEntity<String> payNoticeResponseEntity = payNoticeManager.noticeOrder(payInfoResultBO, payInfo);
            if (Objects.equals(payNoticeResponseEntity.getBody(), ResponseEnum.EXCEPTION.value())) {
                log.error("取消订单的订单成功回调处理失败，{}", payInfoResultBO);
                break;
            }
        }
        return ServerResponseEntity.success(orderIdList);
    }
}
